#pragma once

#include "utils/optimized_multi_price_history.h"
#include "utils/optimized_multi_spread_history.h"
#include "utils/memory_pool.h"
#include "utils/ring_buffer.h"
#include "utils/simd_math.h"
#include <string>
#include <unordered_map>
#include <memory>
#include <mutex>
#include <vector>
#include <functional>
#include <chrono>

namespace hft {

/**
 * @brief 优化的市场数据管理器
 * 
 * 这个类负责管理和处理市场数据，使用内存池、SIMD优化和其他优化技术来提高性能。
 */
class OptimizedMarketDataManager {
public:
    /**
     * @brief 市场数据更新回调函数类型
     */
    using MarketDataCallback = std::function<void(const MarketData&)>;

    /**
     * @brief 构造函数
     * @param price_history_capacity 价格历史容量
     * @param spread_history_capacity 价差历史容量
     */
    OptimizedMarketDataManager(
        size_t price_history_capacity = 1000,
        size_t spread_history_capacity = 1000)
        : price_histories_(price_history_capacity)
        , spread_histories_(spread_history_capacity)
        , market_data_pool_(10000)
        , update_count_(0)
        , last_cleanup_time_(std::chrono::steady_clock::now())
        , cleanup_interval_(std::chrono::minutes(5))  // 每5分钟清理一次
    {
    }

    /**
     * @brief 处理市场数据
     * @param data 市场数据
     */
    void processMarketData(const MarketData& data) {
        try {
            // 使用内存池创建市场数据副本
            auto* data_copy = market_data_pool_.create(data);

            {
                std::lock_guard<std::mutex> lock(mutex_);

                // 更新价格历史
                price_histories_.addPrice(data.symbol, data.close);

                // 更新所有包含此交易品种的价差历史
                updateSpreadHistories(data.symbol, data.close);

                // 调用回调函数
                auto it = callbacks_.find(data.symbol);
                if (it != callbacks_.end()) {
                    for (const auto& callback : it->second) {
                        callback(*data_copy);
                    }
                }

                // 更新最新价格映射
                latest_prices_[data.symbol] = data.close;

                // 增加更新计数
                ++update_count_;
            }

            // 释放市场数据副本
            market_data_pool_.destroy(data_copy);

            // 定期清理
            checkAndCleanup();

        } catch (const std::exception& e) {
            LOG(ERROR) << "处理市场数据时发生错误: " << e.what();
        }
    }

    /**
     * @brief 注册市场数据回调
     * @param symbol 交易品种
     * @param callback 回调函数
     * @return 是否成功注册
     */
    bool registerCallback(const std::string& symbol, MarketDataCallback callback) {
        if (!callback) return false;

        std::lock_guard<std::mutex> lock(mutex_);
        callbacks_[symbol].push_back(std::move(callback));
        return true;
    }

    /**
     * @brief 获取价格历史管理器
     * @return 价格历史管理器引用
     */
    OptimizedMultiPriceHistory& getPriceHistories() {
        return price_histories_;
    }

    /**
     * @brief 获取价差历史管理器
     * @return 价差历史管理器引用
     */
    OptimizedMultiSpreadHistory& getSpreadHistories() {
        return spread_histories_;
    }

    /**
     * @brief 获取特定品种的最新价格
     * @param symbol 交易品种
     * @return 最新价格
     */
    double getLatestPrice(const std::string& symbol) const {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = latest_prices_.find(symbol);
        return it != latest_prices_.end() ? it->second : 0.0;
    }

    /**
     * @brief 获取所有交易品种
     * @return 交易品种列表
     */
    std::vector<std::string> getSymbols() const {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<std::string> symbols;
        symbols.reserve(latest_prices_.size());
        
        for (const auto& pair : latest_prices_) {
            symbols.push_back(pair.first);
        }
        
        return symbols;
    }

    /**
     * @brief 获取更新计数
     * @return 更新计数
     */
    uint64_t getUpdateCount() const {
        return update_count_.load();
    }

    /**
     * @brief 清理未使用的内存
     */
    void shrinkMemoryPools() {
        market_data_pool_.shrink();
    }

    /**
     * @brief 获取系统状态
     * @return JSON格式的状态信息
     */
    std::string getState() const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        nlohmann::json state;
        state["update_count"] = update_count_.load();
        
        // 添加内存池统计信息
        auto [allocated, freed] = market_data_pool_.getStats();
        state["memory_pool"] = {
            {"allocated", allocated},
            {"freed", freed},
            {"active", allocated - freed}
        };
        
        // 添加价格信息
        nlohmann::json prices;
        for (const auto& pair : latest_prices_) {
            prices[pair.first] = pair.second;
        }
        state["latest_prices"] = prices;
        
        // 添加回调信息
        nlohmann::json callbacks;
        for (const auto& pair : callbacks_) {
            callbacks[pair.first] = pair.second.size();
        }
        state["callbacks"] = callbacks;
        
        return state.dump(4);
    }

private:
    /**
     * @brief 更新价差历史
     * @param updated_symbol 更新的交易品种
     * @param price 最新价格
     */
    void updateSpreadHistories(const std::string& updated_symbol, double price) {
        // 获取所有交易品种
        auto symbols = getSymbols();
        
        // 更新所有包含此交易品种的价差
        for (const auto& symbol : symbols) {
            if (symbol != updated_symbol) {
                auto other_price = latest_prices_[symbol];
                auto spread = price - other_price;
                spread_histories_.addSpread(updated_symbol, symbol, spread);
            }
        }
    }

    /**
     * @brief 检查并执行清理
     */
    void checkAndCleanup() {
        auto now = std::chrono::steady_clock::now();
        auto elapsed = now - last_cleanup_time_;
        
        if (elapsed >= cleanup_interval_) {
            // 执行清理
            shrinkMemoryPools();
            last_cleanup_time_ = now;
        }
    }

private:
    OptimizedMultiPriceHistory price_histories_;    // 价格历史管理器
    OptimizedMultiSpreadHistory spread_histories_;  // 价差历史管理器
    utils::MemoryPool<MarketData> market_data_pool_;  // 市场数据对象池
    
    std::unordered_map<std::string, std::vector<MarketDataCallback>> callbacks_;  // 回调函数映射表
    std::unordered_map<std::string, double> latest_prices_;  // 最新价格映射表
    
    mutable std::mutex mutex_;  // 互斥锁
    std::atomic<uint64_t> update_count_;  // 更新计数
    
    std::chrono::steady_clock::time_point last_cleanup_time_;  // 上次清理时间
    std::chrono::duration<int64_t> cleanup_interval_;  // 清理间隔
};

} // namespace hft